# srt_wr.py：字幕的读写，通过夸克云盘
#
# 1. 邮箱发送本地同步到远端，则检索所有srt重命名后放到同步区路径
# 2. 邮箱发送远端同步到本地，则进行文件的hash比较，之后更新原srt
# 3. 手机端编辑同步区的文件，有历史版本

# 待实现：
# -指定电脑的某个路径为云盘自动更新同步路径，设置云端同步区文件为修改时间前后排序
# -自动将生成的所有srt文件放到同步区路径下，同时留做备份
# -将同步区srt文件后面添加doc后缀，这样可以在夸克云盘在线编辑
# -在手机网盘端可以进行随时编辑
# -将最新修改的文件排序后，下载此页，依次比较这个文件和同步区的此文件的hash值是否变化
# -变化了认为是修改了，保留此文件，否则删除，继续下一个文件比较
# -判断完毕后将修改后的文件全部替换同步区文件，删除后缀后移动到原路径
# -邮箱方面只有两条指令 一个是同步本地到云盘，另一个是同步云盘到本地
# 多机测试及坐标标定

# 需要修改的全局变量或配置：
# 关闭网盘自动更新和桌面通知
# 配置夸克云盘的同步区路径和下拉临时区路径
# mp4存储路径和云盘路径不要有重合
# srt_check_path 字幕文件查找路径
# srt_syn_path  字幕文件云盘同步路径
# quark_exe_path  夸克云盘路径
# quark_srt_path  夸克云盘srt路径
# pc平台 PC_COM 据此进行坐标的标正


import smtplib
import eyed3
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from pydub import AudioSegment
import email
import imaplib
import os
import shutil
import time
import traceback
import zipfile
from email.header import decode_header, Header
from email.utils import parseaddr
from pathlib import Path
import datetime
import pyautogui
import pyperclip
from moviepy.editor import VideoFileClip
import hashlib

DEBUG = 1
PC_COM = 1  # 0-家庭 1-公司

remote_server_url = 'imap.qq.com'
email_url = "3324564761@qq.com"  # 当前使用邮箱
password = "ioaeproulegrchff"
email_msg_to = "1984832368@qq.com"  # 发送邮箱
check_time = 10 # n 秒检测一次是否更新

srt_check_path = "D:\\video\\video_temp\\海绵宝宝系列\\第2季"  # 字幕文件检索路径
srt_syn_path = "D:\\video\\srt_temp"  # 字幕文件云盘同步路径 不可删除 否则云盘要重新配置
check_hash_path = "D:\\video\\check_hash_temp"  # 下拉后需要比对hash的文件路径 用后即删
quark_exe_path = '"D:\\Program Files\\quark-cloud-drive\\QuarkCloudDrive.exe"'  # 夸克云盘路径
quark_srt_path = "srt_temp"  # 夸克云盘srt路径

rewrite_print = print
def print(*arg):
   rewrite_print(*arg)
   output_dir = "log_file"
   if not os.path.exists(output_dir):
         os.makedirs(output_dir)
   log_name = 'log.txt' # 日志文件名称
   filename = os.path.join(output_dir, log_name)
   rewrite_print(*arg,file=open(filename,"a")) # 写入文件

def print_d(*arg): #仿真调试用
    if DEBUG == 1:
        print('------调试打印开始-----')
        print(*arg)
        print('------调试打印结束-----\r\n')


class email_data:
    def __init__(self):
        self.From = ""
        self.Subject = ""
        self.Date = ""
        self.filename = ""
        self.count = 0
        self.main_body = ""


    def printf(self, who):
        print(f'==========================================以上为调试，以下为{who}的真实有效数据========================================')
        print("From :% s ; Subject:% s ;  Date:% s ;  filename:% s ;  count:% s ;  main_body:% s ; " % (self.From, self.Subject, self.Date, self.filename, self.count, self.main_body))
        print(f'==========================================以上为{who}的真实有效数据==================================================')

    def reset(self):
        self.From = ""
        self.Subject = ""
        self.Date = ""
        self.filename = ""
        self.main_body = ""  #邮箱


class doc_function():  # 文件操作
    def save_data_txt(data):  # 添加数据到文件
        info_str = str(data)
        info_str += '\r\n'
        print(info_str)
        with open('flash_tool.log', 'a') as lead:
            lead.write(info_str)

    def set_data(data):  # 重写文件
        data_w = "data  " + data
        fi = open('data.txt', 'w', encoding='utf-8')
        fi.write(data_w)

    def mkdir(path):  # 新建文件夹
        folder = os.path.exists(path)

        if not folder:  # 判断是否存在文件夹如果不存在则创建为文件夹
            os.makedirs(path)  # makedirs 创建文件时如果路径不存在会创建这个路径
            print("---  new folder...  ---")
        else:
            print("folder is:", path)

    def copyfile_no_dele(srcfile, dstpath):  # 复制文件 如果目标路径存在同名文件则不复制
        if not os.path.isfile(srcfile):
            print("%s not exist!" % (srcfile))
        else:
            fpath, fname = os.path.split(srcfile)  # 分离文件名和路径
            sample_name = srt_syn_path + "\\" + fname
            if os.path.exists(sample_name) == False:
                shutil.copy(srcfile, dstpath)  # 复制文件
            else:
                print("\r\n不进行复制，已经存在文件", sample_name)

    def copyfile_dele(srcfile, dstpath):  # 复制文件 如果目标路径存在同名文件则删除源文件
        if not os.path.isfile(srcfile):
            print("%s not exist!" % (srcfile))
        else:
            fpath, fname = os.path.split(srcfile)  # 分离文件名和路径
            sample_name = srt_syn_path + "\\" + fname
            if os.path.exists(sample_name) == False: # 不存在同名文件
                shutil.copy(srcfile, dstpath)  # 复制文件
            else:
                os.remove(sample_name) # 删除源文件
                shutil.copy(srcfile, dstpath)  # 复制文件

    def file_zip(start_file, zip_dir):  # 压缩文件
        # start_dir 要压缩的文件
        # zip_file 输出zip文件的路径
        fpath_start_dir, fname = os.path.split(start_file)  # 分离文件名和路径

        zip_file = zip_dir + '.zip'
        z = zipfile.ZipFile(zip_file, 'w', zipfile.ZIP_DEFLATED)
        print(z)
        for path, dirname, file_name in os.walk(fpath_start_dir):
            # print("文件夹根路径：", path)
            fpath = path.replace(fpath_start_dir, '')  # 去除根路径名称
            # print("--去除根路径：", fpath)
            fpath = fpath and fpath + os.sep  # 在原fpath加上\
            # print("****去除根路径+\ ：", fpath)

            for filename in file_name:  # 逐个循环读取文档名称
                if filename.find(fname) >= 0:
                    # print(filename)
                    z.write(os.path.join(path, filename), fpath + filename)  # 实现在输出路径的Zip压缩操作
        z.close()


    def file_unzip_download(unzip_file):
        print(f"开始进行解压缩并下载···")

        zip_file = zipfile.ZipFile(unzip_file)
        fpath, fname = os.path.split(unzip_file)
        out_file = fpath + "\\unzip"
        if os.path.isdir(out_file):
            shutil.rmtree(out_file)
            os.mkdir(out_file)
        else:
            os.mkdir(out_file)
        for names in zip_file.namelist():
            zip_file.extract(names, out_file)
        zip_file.close()
        folder = Path(out_file.strip())
        result = list(folder.rglob(f'*{".hex"}*'))  # 只要hex文件
        print(result[0])  # 默认一个压缩包只有一个文件
        flash_file = str(result[0])
        # 进行文件的各种操作处理
        shutil.rmtree(out_file)

    def search_file(key_word, self_path=None):  # 查找的关键字 self_path是自定义路径
        if self_path != None:
            folder_str = self_path
        else:
            folder_str = os.path.join(os.getcwd(), qq_email_rx.Subject)  # 刘森 新世界

        folder = Path(folder_str.strip())
        print(folder)
        if folder.exists():
            print("开始根据关键字查找文件···")
        else:
            print("未找到存放关键字对应文件的文件夹")
            return None

        result = list(folder.rglob(f'*{key_word}*'))
        if not result:
            print(f'在{folder} 下未找到关键字名称 {key_word} 的文件夹或文件')
            return None
        else:
            print(f'在{folder} 下找到关键字名称 {key_word} 的文件夹或文件{result}')
            return result

    def get_str_row_column(words): #获取字符串中行数和列的最大字符数，返回两者的最大值
        row = words.count("\n") + 1

        # 存储所有的相同字符之间的距离
        length = []
        loc = 0
        last_loc = 0

        while words.find("\n", loc+1) != -1:
            loc = words.find("\n", loc+1)

            length.append(loc - last_loc)
            last_loc = loc

        length.append(len(words) - last_loc) # 获取最后一行长度
        # print(length)
        # print(f'最大长度：{max(length)}')
        column = max(length)
        # print(max(row, column))
        return max(row, column)

    def delete_files(file_path):
        if os.path.exists(file_path):
            shutil.rmtree(file_path)
            return True
        else:
            # file not found message
            print(f'要删除的文件夹{file_path}找不到')
            return False

    def diff_delete_file(path1, path2): # 对比两个文件夹，删除path1中多余文件
        fileName1 = set([_ for _ in os.listdir(path1)])
        fileName2 = set([_ for _ in os.listdir(path2)])
        diffs = fileName1.difference(fileName2)  # fileName1对比fileName2，fileName1中多出来的文件；注意，如果fileName2里有fileName1中没有的文件，也不会筛选出来
        filePath = [os.path.join(path1, i) for i in diffs]
        for file in filePath:
            os.remove(file)
        print("删除的文件有：", filePath)

    def hash(file_path, Bytes=1024):  # 计算文件hash
        md5_value = hashlib.md5()  # 创建一个md5算法对象
        with open(file_path, 'rb') as f:  # 打开一个文件，必须是'rb'模式打开
            while 1:
                data = f.read(Bytes)  # 由于是一个文件，每次只读取固定字节
                if data:  # 当读取内容不为空时对读取内容进行update
                    md5_value.update(data)
                else:  # 当整个文件读完之后停止update
                    break
        ret = md5_value.hexdigest()  # 获取这个文件的MD5值
        return ret

class py_gui:
    def __init__(self):  # 不同电脑的gui坐标值不一样
        pyautogui.PAUSE = 0.5 # 所有操作暂停0.5s

        self.dpi_x = pyautogui.size()[0]  # 长 默认2240
        self.dpi_y = pyautogui.size()[1]  # 高 默认1400

        self.x_radio = self.dpi_x/2240  # 自动进行坐标换算
        self.y_radio = self.dpi_y/1400


    def click(time_s = None):
        if time_s != None:
            time.sleep(time_s)
        pyautogui.click()

    def doubleClick(time_s = None):
        if time_s != None:
            time.sleep(time_s)
        pyautogui.doubleClick()

    def move_click(self, x, y, time_s = None):  # 鼠标移动到位置延时点击
        x = int((x) * (self.x_radio))
        y = int((y) * (self.y_radio))
        print(x, y)

        pyautogui.moveTo(x, y)
        py_gui.click(time_s)

    def dragTo(self, x, y):  # 默认左键拖拽
        x = int((x) * (self.x_radio))
        y = int((y) * (self.y_radio))

        pyautogui.dragTo(x, y, 1, button="left")

    def check_completed(self, x, y, r=None, g=None, b=None): # 判断是否完成某项内容 检测某个点的rgb值，如果rgb变化了认为有动作  或者如果符合rgb的值认为成功
        # 一直等待生成完成 判断x y 的rgb是不是r g b （识别中） 不考虑识别失败情况
        x = int((x) * (self.x_radio))
        y = int((y) * (self.y_radio))

        pyautogui.moveTo(x, y, 2)
        rgb = pyautogui.screenshot().getpixel((x, y))
        r_last = rgb[0]
        g_last = rgb[1]
        b_last = rgb[2]
        time.sleep(5)

        if r == None or g == None or b == None: # 有一点像素变化认为完成
            while rgb[0] == r_last and rgb[1] == g_last and rgb[2] == b_last:  # 没有颜色变化
                rgb = pyautogui.screenshot().getpixel((x, y))
                posi = 'x:' + str(x).rjust(4) + ' y:' + str(y).rjust(4) + '  RGB:' + str(rgb)
                print("等待···", posi)
                time.sleep(1)
            print("发现颜色变化")
        else: # 符合rgb认为完成
            while rgb[0] != r and rgb[1] != g and rgb[2] != b:  # 没有出现符合的颜色
                rgb = pyautogui.screenshot().getpixel((x, y))
                posi = 'x:' + str(x).rjust(4) + ' y:' + str(y).rjust(4) + '  RGB:' + str(rgb)
                print("等待···", posi)
                time.sleep(1)
            print("发现符合的颜色")


class email_parse:  #邮件处理
    def __init__(self,remote_server_url,email_url,password):
        self.remote_server_url = remote_server_url
        self.email_url = email_url
        self.password = password

        self.subject_name = " "

    def decode_str(s):  # 解码字符串
        value, charset = decode_header(s)[0]
        if charset:
            value = value.decode(charset)
        return value

    def set_charset(msg):  # 设置字符集
        charset = msg.get_charset()  # 获取字符集
        if charset is None:
            content_type = msg.get('Content-Type', '').lower()
            pos = content_type.find('charset=')
            if pos >= 0:
                charset = content_type[pos + 8:].strip()
        return charset

    def send_email(msg_from, passwd, msg_to, subject_rx, text_content, file_path=None): # 邮箱数据返回
      msg = MIMEMultipart()
      subject = subject_rx  # 主题
      text = MIMEText(text_content)
      msg.attach(text)

      if file_path:  # 最开始的函数参数我默认设置了None ，想添加附件，自行更改一下就好
          docFile = file_path
          docApart = MIMEApplication(open(docFile, 'rb').read())
          docApart.add_header('Content-Disposition', 'attachment', filename=docFile)
          msg.attach(docApart)
          print('发送附件:', file_path)
      msg['Subject'] = subject
      msg['From'] = msg_from
      msg['To'] = msg_to
      try:
          s = smtplib.SMTP_SSL("smtp.qq.com", 465)
          s.login(msg_from, passwd)
          s.sendmail(msg_from, msg_to, msg.as_string())
          print("邮件发送成功")
      except smtplib.SMTPException as e:
          print("邮件发送失败")
      finally:
          s.quit()


    def email_back(file_type): # 进行邮箱数据的返回 不同文件类型返回不同信息
        print('邮箱数据返回...')
        file_path = None
        if qq_email_tx.main_body == "":
            qq_email_tx.main_body = "没有匹配项，请检查主文格式和附件后重新发送，以下为所有指令\r\n 上传（同步本地到远端）" \
                                    "\r\n下拉（同步远端到本地）\r\n"

        if qq_email_rx.filename != "":  # 有附件
            # 收到 进行srt文件修改 指令
            if qq_email_rx.filename[0].find("srt") != -1:  # 进行srt文件修改
                # 处理临时区的附件 保存和覆盖
                qq_email_tx.main_body = "已经保存srt文件\r\n"
            else:
                qq_email_tx.main_body = "未收到规定srt文件格式" + "-------请发-- srt+文件名+修改后的附件！！！"

            # 将临时区的附件删除

        else:  # 没有附件
            # 收到 目录
            if qq_email_rx.Subject.find("上传") != -1:  # 检索所有srt目录

                # 上传检索路径下的所有srt文件
                check_file = ".srt"
                print_d(check_file)
                file_list = doc_function.search_file(check_file, srt_check_path)
                if file_list[0] == None: # 未找到一个srt文件
                    qq_email_tx.main_body = f'在{srt_check_path}路径下未找到srt文件，请确认查找路径是否正确'
                else:
                    # 将所有srt文件复制到 srt_syn_path 同步路径下面
                    srt_no_syn = ""
                    doc_function.mkdir(srt_syn_path)  # 创建文件夹
                    for srt_file in file_list:
                        doc_function.copyfile_no_dele(srt_file, srt_syn_path)  # 将srt复制到对应子文件夹
                        # 将文件名字后缀改为doc
                        fpath, fname = os.path.split(srt_file)
                        syn_file = srt_syn_path + "\\" + fname
                        portion = os.path.splitext(syn_file)
                        newname = portion[0] + ".doc"
                        try:
                            os.rename(syn_file, newname)
                            srt_no_syn = "\r\n" + srt_no_syn + fpath + "\\" + fname + "\r\n"
                        except:
                            print("文件已存在")
                            os.remove(syn_file)
                            continue

                    if srt_no_syn == "":
                        qq_email_tx.main_body = f'在{srt_check_path}路径下未找到未同步的srt文件，之前已全部同步'
                    else:
                        qq_email_tx.main_body = f'在{srt_check_path}路径下找到未同步的srt文件：{srt_no_syn} 并进行同步成功'


            # 下拉所有srt文件到同步区
            elif qq_email_rx.Subject.find("下拉") != -1:  # 检索所有srt文件
                # 网盘初始化
                pyautogui.hotkey('win', 'd')  # 先清空屏幕
                os.startfile(quark_exe_path)  # 将软件放到桌面上
                time.sleep(1)
                pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
                time.sleep(1)
                pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
                doc_function.mkdir(check_hash_path)  # 创建用于比对hash的文件夹 也是下拉内容临时存放区

                if PC_COM == 1:  # 公司PC 2240*1040
                    # 进行一页网盘文档数据的下载
                    gui.move_click(62, 62, 0.1)  # 点击首页
                    gui.move_click(1510, 48, 0.1)  # 点击搜索框
                    pyperclip.copy(quark_srt_path)  # 输入查找文件夹
                    pyautogui.hotkey('ctrl', 'v')
                    gui.check_completed(449, 205, 158, 197, 255)  # 等待检索完成
                    gui.move_click(449, 205, 0.1)  # 点击文件夹
                    gui.check_completed(485, 295, 221, 221, 221)  # 等待刷新
                    gui.move_click(406, 353, 0.1)  # 点击全选
                    gui.move_click(1695, 123, 0.1)  # 点击下载
                    time.sleep(2)
                    pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
                    gui.move_click(1674, 74, 0.1)  # 点击输出框
                    pyperclip.copy(check_hash_path) # 输入下载路径
                    pyautogui.hotkey('ctrl', 'v')
                    pyautogui.press('enter')
                    gui.move_click(1955, 1296, 0.1)  # 点击选择文件夹

                    # 等待下载完成
                    gui.move_click(62, 270, 1)  # 点击传输
                    gui.move_click(225, 198, 1)  # 点击下载
                    gui.move_click(429, 135, 1)  # 点击正在下载
                    gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完
                    time.sleep(0.2)
                    gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完 多次确认
                else:  # 家用PC
                    # 进行一页网盘文档数据的下载
                    gui.move_click(62, 62, 0.1)  # 点击首页
                    gui.move_click(1510, 48, 0.1)  # 点击搜索框
                    pyperclip.copy(quark_srt_path)  # 输入查找文件夹
                    pyautogui.hotkey('ctrl', 'v')
                    gui.check_completed(449, 205, 158, 197, 255)  # 等待检索完成
                    gui.move_click(449, 205, 0.1)  # 点击文件夹
                    gui.check_completed(485, 295, 221, 221, 221)  # 等待刷新
                    gui.move_click(406, 353, 0.1)  # 点击全选
                    gui.move_click(1695, 123, 0.1)  # 点击下载
                    time.sleep(2)
                    pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
                    gui.move_click(1674, 74, 0.1)  # 点击输出框
                    pyperclip.copy(check_hash_path)  # 输入下载路径
                    pyautogui.hotkey('ctrl', 'v')
                    pyautogui.press('enter')
                    gui.move_click(1955, 1296, 0.1)  # 点击选择文件夹

                    # 等待下载完成
                    gui.move_click(62, 270, 1)  # 点击传输
                    gui.move_click(225, 198, 1)  # 点击下载
                    gui.move_click(429, 135, 1)  # 点击正在下载
                    gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完
                    time.sleep(0.2)
                    gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完 多次确认

                # 根据同名文件hash是否变化，来进行文件更新
                doc_function.diff_delete_file(check_hash_path, srt_syn_path) # 删除多余文件
                srt_syn = ""
                files = os.listdir(check_hash_path)  # 文件对比
                for file in files:  # 进行文件的比对 通过hash值
                    new_file_path = check_hash_path + "\\" + file
                    hash_new = doc_function.hash(new_file_path)
                    old_file_path = srt_syn_path + "\\" + file
                    hash_old = doc_function.hash(old_file_path)
                    if hash_new != hash_old:  # 文件变化
                        srt_syn = "\r\n" + srt_syn + old_file_path + "\r\n"
                        print("文件发生改动：", new_file_path)
                        doc_function.copyfile_dele(new_file_path, srt_syn_path)  # 复制新文件

                        # 修改new_file_path文件后缀为srt
                        new_file_name = new_file_path.replace('.doc', '.srt')
                        os.rename(new_file_path, new_file_name)

                        # 将此文件更新到原路径
                        fpath, fname = os.path.split(new_file_name)  # 分离文件名和路径
                        mp4_srt_path = doc_function.search_file(fname, srt_check_path)[0]
                        if mp4_srt_path != None:
                            fpath, fname = os.path.split(mp4_srt_path)
                            doc_function.copyfile_dele(new_file_name, fpath)  # 复制新文件


                        # 查找修改的特殊字符，以此进行剪切视频
                        print_d(new_file_name)

                doc_function.delete_files(check_hash_path) # 将文件夹删除
                # input()

                if srt_syn == "":
                    qq_email_tx.main_body = f'为从网盘下拉同步srt文件到{srt_syn_path}，没有文件发生修改'
                else:
                    qq_email_tx.main_body = f'已经从网盘下拉同步到{srt_syn_path}的srt文件：{srt_syn} '

            else:
                qq_email_tx.main_body = "不是指定的指令 请发送 上传（同步本地到远端） 或 下拉（同步远端到本地）"

        qq_email_tx.printf("发送")
        if DEBUG == 0:  # 调试的时候不返回数据
            email_parse.send_email(email_url, password, email_msg_to, qq_email_rx.Subject, qq_email_tx.main_body, file_path)


    def download_file(msg):  # 保存附件到指定路径
        fpath = os.getcwd()
        path_name = qq_email_rx.Subject  # 获取主题名字，作为文件夹名字 临时区

        out_file = fpath + "\\" + path_name
        print('文件保存路径是：', out_file)
        doc_function.mkdir(out_file)  #创建文件夹

        # 获取邮件主体信息
        attachment_files = []
        for part in msg.walk():
            file_name = part.get_filename()  # 获取附件名称类型
            contentType = part.get_content_type()  # 获取数据类型
            mycode = part.get_content_charset()  # 获取编码格式
            if file_name:
                h = Header(file_name)
                dh = decode_header(h)  # 对附件名称进行解码
                filename_download = dh[0][0]
                if dh[0][1]:
                    filename_download = email_parse.decode_str(str(filename_download, dh[0][1]))  # 将附件名称可读化
                attachment_files.append(filename_download)
                data = part.get_payload(decode=True)  # 下载附件
                with open(out_file + "\\" + filename_download, 'wb') as f:  # 在当前目录下创建文件，注意二进制文件需要用wb模式打开
                    f.write(data)  # 保存附件
                # 进行文件重命名，加上时间
                qq_email_rx.filename = attachment_files
                src = out_file + "\\" + filename_download
                if qq_email_rx.filename[0].find(".mp3") != -1:  # 音频文件
                    dst = out_file + "\\" + "mp3-" + qq_email_rx.Date + filename_download
                    time.sleep(2) # 为下载和重命名留时间
                elif qq_email_rx.filename[0].find(".jpg") != -1 or qq_email_rx.filename[0].find(".bmp") != -1 or qq_email_rx.filename[0].find(".png") != -1:  # 图片文件 重命名-在原类型数量基础上递增
                    pic_name = doc_function.search_file("pic")
                    if pic_name == None:
                        pic_num = 0
                    else:
                        pic_num = len(pic_name)
                    dst = out_file + "\\" + "pic" + str(pic_num) + "-" + qq_email_rx.Date + filename_download
                    qq_email_tx.main_body = qq_email_tx.main_body + str(pic_num) + "-"
                else: # 其它类型
                    dst = out_file + "\\" + qq_email_rx.Date + filename_download

                try:
                    os.rename(src, dst)
                except: # 文件重复异常处理
                    os.remove(dst)
                    os.rename(src, dst)

                print(f'附件 {filename_download} 已下载及重命名完成')

            elif contentType == 'text/plain':  # or contentType == 'text/html':
                # 输出正文 也可以写入文件
                data = part.get_payload(decode=True)
                content = data.decode(mycode)
                qq_email_rx.main_body = content
                # print('正文：', content)
        # print('附件文件名列表', qq_email_rx.filename)

    def get_email_title(msg):   # 获取发件人，主题和发送日期  返回主题名字
        for header in ['From', 'Subject', 'Date']:  # 遍历获取发件人，主题的相关信息
            value = msg.get(header, '')  # 获取邮件头的内容
            if value != '':
                if header == 'From':  # 解析字符串中的邮件地址
                    hdr, addr = parseaddr(value)
                    name = email_parse.decode_str(hdr)  # 解码字符串
                    value = '%s <%s>' % (name, addr)
                    qq_email_rx.From = name

                elif header == 'Subject': # 获取主题的信息，并解码
                    value = email_parse.decode_str(value)  # 解码字符串
                    if value.find("回复") != -1:  # 是回复信息
                        # 以回复后面的内容以此为文件夹
                        qq_email_rx.Subject = value[3:]
                        print(qq_email_rx.Subject)
                    else:
                        qq_email_rx.Subject = value

                elif header == 'Date':  # 获取日期的信息，并解码
                    value = email_parse.decode_str(value)  # 解码字符串
                    print(value)
                    time_format = datetime.datetime.strptime(value, '%a, %d %b %Y %H:%M:%S +%f')
                    qq_email_rx.Date = time_format.strftime("%Y-%m-%d %H-%M-%S-")
                    print(qq_email_rx.Date)


                print('%s: %s' % (header, value))

    def get_email_update(space): # 每隔space秒检测一次是否更新，进行状态返回，如果更新返回最新的邮件数量，否则返回0
        if DEBUG == 0:
            time.sleep(space)

        server = imaplib.IMAP4_SSL(remote_server_url, 993)
        server.login(email_url, password)
        server.select('INBOX')
        status, data = server.search(None, "ALL")
        if status != 'OK':
            raise Exception('read email error')
        emailids = data[0].split()
        mail_counts = len(emailids)
        current_time = datetime.datetime.now()
        current_time = current_time.strftime("%Y-%m-%d-%H:%M:%S")
        print(f'{str(current_time)}-邮件数量是 {mail_counts}')
        if mail_counts > qq_email_rx.count and qq_email_rx.count != 0 or DEBUG == 1:
            qq_email_rx.count = mail_counts
            return qq_email_rx.count
        else:
            qq_email_rx.count = mail_counts
            return 0

    def main_parse_Email(self):  # 处理email数据
        qq_email_rx.reset()
        qq_email_tx.reset()
        counts = email_parse.get_email_update(check_time)

        if counts == 0: # 未更新
            return
        else:
            server = imaplib.IMAP4_SSL(self.remote_server_url, 993)
            server.login(self.email_url, self.password)
            server.select('INBOX')
            status, data = server.search(None, "ALL")
            if status != 'OK':
                raise Exception('read email error')
            emailids = data[0].split()
            mail_counts = counts

            status, edata = server.fetch(emailids[mail_counts-1], '(RFC822)')
            msg = email.message_from_bytes(edata[0][1])

            email_parse.get_email_title(msg) # 获取email title
            if qq_email_rx.From.find("叶绿素") == -1: # 不是指定邮箱的邮件
                print("不是指定邮箱发的文件")
                return
            elif qq_email_rx.Subject.find("上传") == -1 and qq_email_rx.Subject.find("下拉") == -1:  # 不是指定的指令
                print("不是指定的指令 请发送 上传（同步本地到远端） 或 下拉（同步远端到本地）")
                return

            # 附件保存
            # email_parse.download_file(msg)

            qq_email_rx.printf("接收")

            # 进行数据返回
            email_parse.email_back(qq_email_rx.filename)




if __name__ == "__main__":
    print("开始进行字幕的检索和读写 !!!!")
    gui = py_gui()
    qq_email_rx = email_data()
    qq_email_tx = email_data()
    email_rx = email_parse(remote_server_url, email_url, password)
    os.startfile(quark_exe_path)  # 打开软件
    time.sleep(2)
    while 1:
        try:
            email_rx.main_parse_Email()
        except:
            print("error")
            traceback.print_exc()
            continue






